Algorand MCP

MIT License

100

Overview InspectNew Endpoints Schema Related Servers Reviews Score

{
  "components": {
    "parameters": {
      "account-id": {
        "description": "account string",
        "in": "path",
        "name": "account-id",
        "required": true,
        "schema": {
          "type": "string",
          "x-go-name": "AccountID"
        },
        "x-go-name": "AccountID"
      },
      "address": {
        "description": "Only include transactions with this address in one of the transaction fields.",
        "in": "query",
        "name": "address",
        "schema": {
          "type": "string"
        }
      },
      "address-role": {
        "description": "Combine with the address parameter to define what type of address to search for.",
        "in": "query",
        "name": "address-role",
        "schema": {
          "enum": [
            "sender",
            "receiver",
            "freeze-target"
          ],
          "type": "string"
        }
      },
      "after-time": {
        "description": "Include results after the given time. Must be an RFC 3339 formatted string.",
        "in": "query",
        "name": "after-time",
        "schema": {
          "format": "date-time",
          "type": "string",
          "x-algorand-format": "RFC3339 String"
        },
        "x-algorand-format": "RFC3339 String"
      },
      "asset-id": {
        "description": "Asset ID",
        "in": "query",
        "name": "asset-id",
        "schema": {
          "type": "integer",
          "x-go-name": "AssetID"
        },
        "x-go-name": "AssetID"
      },
      "before-time": {
        "description": "Include results before the given time. Must be an RFC 3339 formatted string.",
        "in": "query",
        "name": "before-time",
        "schema": {
          "format": "date-time",
          "type": "string",
          "x-algorand-format": "RFC3339 String"
        },
        "x-algorand-format": "RFC3339 String"
      },
      "catchpoint": {
        "description": "A catch point",
        "in": "path",
        "name": "catchpoint",
        "required": true,
        "schema": {
          "format": "catchpoint",
          "pattern": "[0-9]{1,10}#[A-Z0-9]{1,53}",
          "type": "string",
          "x-algorand-format": "Catchpoint String"
        },
        "x-algorand-format": "Catchpoint String"
      },
      "currency-greater-than": {
        "description": "Results should have an amount greater than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
        "in": "query",
        "name": "currency-greater-than",
        "schema": {
          "type": "integer"
        }
      },
      "currency-less-than": {
        "description": "Results should have an amount less than this value. MicroAlgos are the default currency unless an asset-id is provided, in which case the asset will be used.",
        "in": "query",
        "name": "currency-less-than",
        "schema": {
          "type": "integer"
        }
      },
      "exclude-close-to": {
        "description": "Combine with address and address-role parameters to define what type of address to search for. The close to fields are normally treated as a receiver, if you would like to exclude them set this parameter to true.",
        "in": "query",
        "name": "exclude-close-to",
        "schema": {
          "type": "boolean"
        }
      },
      "format": {
        "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
        "in": "query",
        "name": "format",
        "schema": {
          "enum": [
            "json",
            "msgpack"
          ],
          "type": "string"
        }
      },
      "limit": {
        "description": "Maximum number of results to return.",
        "in": "query",
        "name": "limit",
        "schema": {
          "type": "integer"
        }
      },
      "max": {
        "description": "Truncated number of transactions to display. If max=0, returns all pending txns.",
        "in": "query",
        "name": "max",
        "schema": {
          "type": "integer"
        }
      },
      "max-round": {
        "description": "Include results at or before the specified max-round.",
        "in": "query",
        "name": "max-round",
        "schema": {
          "type": "integer"
        }
      },
      "min-round": {
        "description": "Include results at or after the specified min-round.",
        "in": "query",
        "name": "min-round",
        "schema": {
          "type": "integer"
        }
      },
      "next": {
        "description": "The next page of results. Use the next token provided by the previous results.",
        "in": "query",
        "name": "next",
        "schema": {
          "type": "string"
        }
      },
      "note-prefix": {
        "description": "Specifies a prefix which must be contained in the note field.",
        "in": "query",
        "name": "note-prefix",
        "schema": {
          "type": "string",
          "x-algorand-format": "base64"
        },
        "x-algorand-format": "base64"
      },
      "round": {
        "description": "Include results for the specified round.",
        "in": "query",
        "name": "round",
        "schema": {
          "type": "integer"
        }
      },
      "round-number": {
        "description": "Round number",
        "in": "path",
        "name": "round-number",
        "required": true,
        "schema": {
          "type": "integer"
        }
      },
      "sig-type": {
        "description": "SigType filters just results using the specified type of signature:\n* sig - Standard\n* msig - MultiSig\n* lsig - LogicSig",
        "in": "query",
        "name": "sig-type",
        "schema": {
          "enum": [
            "sig",
            "msig",
            "lsig"
          ],
          "type": "string"
        }
      },
      "tx-id": {
        "description": "Lookup the specific transaction by ID.",
        "in": "query",
        "name": "tx-id",
        "schema": {
          "type": "string",
          "x-algorand-format": "Address",
          "x-go-name": "TxID"
        },
        "x-algorand-format": "Address",
        "x-go-name": "TxID"
      },
      "tx-type": {
        "in": "query",
        "name": "tx-type",
        "schema": {
          "enum": [
            "pay",
            "keyreg",
            "acfg",
            "axfer",
            "afrz",
            "appl",
            "stpf"
          ],
          "type": "string"
        }
      }
    },
    "responses": {
      "AccountApplicationResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "app-local-state": {
                  "$ref": "#/components/schemas/ApplicationLocalState"
                },
                "created-app": {
                  "$ref": "#/components/schemas/ApplicationParams"
                },
                "round": {
                  "description": "The round for which this information is relevant.",
                  "type": "integer"
                }
              },
              "required": [
                "round"
              ],
              "type": "object"
            }
          }
        },
        "description": "AccountApplicationResponse describes the account's application local state and global state (AppLocalState and AppParams, if either exists) for a specific application ID. Global state will only be returned if the provided address is the application's creator."
      },
      "AccountAssetResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "asset-holding": {
                  "$ref": "#/components/schemas/AssetHolding"
                },
                "created-asset": {
                  "$ref": "#/components/schemas/AssetParams"
                },
                "round": {
                  "description": "The round for which this information is relevant.",
                  "type": "integer"
                }
              },
              "required": [
                "round"
              ],
              "type": "object"
            }
          }
        },
        "description": "AccountAssetResponse describes the account's asset holding and asset parameters (if either exist) for a specific asset ID. Asset parameters will only be returned if the provided address is the asset's creator."
      },
      "AccountResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Account"
            }
          }
        },
        "description": "AccountResponse wraps the Account type in a response."
      },
      "ApplicationResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Application"
            }
          }
        },
        "description": "Application information"
      },
      "AssetResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Asset"
            }
          }
        },
        "description": "Asset information"
      },
      "BlockHashResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "blockHash": {
                  "description": "Block header hash.",
                  "type": "string"
                }
              },
              "required": [
                "blockHash"
              ],
              "type": "object"
            }
          }
        },
        "description": "Hash of a block header."
      },
      "BlockResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "block": {
                  "description": "Block header data.",
                  "properties": {},
                  "type": "object",
                  "x-algorand-format": "BlockHeader"
                },
                "cert": {
                  "description": "Optional certificate object. This is only included when the format is set to message pack.",
                  "properties": {},
                  "type": "object",
                  "x-algorand-format": "BlockCertificate"
                }
              },
              "required": [
                "block"
              ],
              "type": "object"
            }
          }
        },
        "description": "Encoded block object."
      },
      "BoxResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Box"
            }
          }
        },
        "description": "Box information"
      },
      "BoxesResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "boxes": {
                  "items": {
                    "$ref": "#/components/schemas/BoxDescriptor"
                  },
                  "type": "array"
                }
              },
              "required": [
                "boxes"
              ],
              "type": "object"
            }
          }
        },
        "description": "Box names of an application"
      },
      "CatchpointAbortResponse": {
        "description": "An catchpoint abort response.",
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "catchup-message": {
                  "description": "Catchup abort response string",
                  "type": "string"
                }
              },
              "required": [
                "catchup-message"
              ],
              "type": "object"
            }
          }
        }
      },
      "CatchpointStartResponse": {
        "description": "An catchpoint start response.",
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "catchup-message": {
                  "description": "Catchup start response string",
                  "type": "string"
                }
              },
              "required": [
                "catchup-message"
              ],
              "type": "object"
            }
          }
        }
      },
      "CompileResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "hash": {
                  "description": "base32 SHA512_256 of program bytes (Address style)",
                  "type": "string"
                },
                "result": {
                  "description": "base64 encoded program bytes",
                  "type": "string"
                },
                "sourcemap": {
                  "description": "JSON of the source map",
                  "properties": {},
                  "type": "object"
                }
              },
              "required": [
                "hash",
                "result"
              ],
              "type": "object"
            }
          }
        },
        "description": "Teal compile Result"
      },
      "DisassembleResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "result": {
                  "description": "disassembled Teal code",
                  "type": "string"
                }
              },
              "required": [
                "result"
              ],
              "type": "object"
            }
          }
        },
        "description": "Teal disassembly Result"
      },
      "DryrunResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "error": {
                  "type": "string"
                },
                "protocol-version": {
                  "description": "Protocol version is the protocol version Dryrun was operated under.",
                  "type": "string"
                },
                "txns": {
                  "items": {
                    "$ref": "#/components/schemas/DryrunTxnResult"
                  },
                  "type": "array"
                }
              },
              "required": [
                "error",
                "protocol-version",
                "txns"
              ],
              "type": "object"
            }
          }
        },
        "description": "DryrunResponse contains per-txn debug information from a dryrun."
      },
      "GetBlockTimeStampOffsetResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "offset": {
                  "description": "Timestamp offset in seconds.",
                  "type": "integer"
                }
              },
              "required": [
                "offset"
              ],
              "type": "object"
            }
          }
        },
        "description": "Response containing the timestamp offset in seconds"
      },
      "GetSyncRoundResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "round": {
                  "description": "The minimum sync round for the ledger.",
                  "type": "integer"
                }
              },
              "required": [
                "round"
              ],
              "type": "object"
            }
          }
        },
        "description": "Response containing the ledger's minimum sync round"
      },
      "LedgerStateDeltaForTransactionGroupResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/LedgerStateDelta"
            }
          }
        },
        "description": "Response containing a ledger state delta for a single transaction group."
      },
      "LedgerStateDeltaResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/LedgerStateDelta"
            }
          }
        },
        "description": "Contains ledger deltas"
      },
      "LightBlockHeaderProofResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/LightBlockHeaderProof"
            }
          }
        },
        "description": "Proof of a light block header."
      },
      "NodeStatusResponse": {
        "description": "NodeStatus contains the information about a node status",
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "catchpoint": {
                  "description": "The current catchpoint that is being caught up to",
                  "type": "string"
                },
                "catchpoint-acquired-blocks": {
                  "description": "The number of blocks that have already been obtained by the node as part of the catchup",
                  "type": "integer"
                },
                "catchpoint-processed-accounts": {
                  "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup",
                  "type": "integer"
                },
                "catchpoint-processed-kvs": {
                  "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup",
                  "type": "integer"
                },
                "catchpoint-total-accounts": {
                  "description": "The total number of accounts included in the current catchpoint",
                  "type": "integer"
                },
                "catchpoint-total-blocks": {
                  "description": "The total number of blocks that are required to complete the current catchpoint catchup",
                  "type": "integer"
                },
                "catchpoint-total-kvs": {
                  "description": "The total number of key-values (KVs) included in the current catchpoint",
                  "type": "integer"
                },
                "catchpoint-verified-accounts": {
                  "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup",
                  "type": "integer"
                },
                "catchpoint-verified-kvs": {
                  "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup",
                  "type": "integer"
                },
                "catchup-time": {
                  "description": "CatchupTime in nanoseconds",
                  "type": "integer"
                },
                "last-catchpoint": {
                  "description": "The last catchpoint seen by the node",
                  "type": "string"
                },
                "last-round": {
                  "description": "LastRound indicates the last round seen",
                  "type": "integer"
                },
                "last-version": {
                  "description": "LastVersion indicates the last consensus version supported",
                  "type": "string"
                },
                "next-version": {
                  "description": "NextVersion of consensus protocol to use",
                  "type": "string"
                },
                "next-version-round": {
                  "description": "NextVersionRound is the round at which the next consensus version will apply",
                  "type": "integer"
                },
                "next-version-supported": {
                  "description": "NextVersionSupported indicates whether the next consensus version is supported by this node",
                  "type": "boolean"
                },
                "stopped-at-unsupported-round": {
                  "description": "StoppedAtUnsupportedRound indicates that the node does not support the new rounds and has stopped making progress",
                  "type": "boolean"
                },
                "time-since-last-round": {
                  "description": "TimeSinceLastRound in nanoseconds",
                  "type": "integer"
                },
                "upgrade-delay": {
                  "description": "Upgrade delay",
                  "type": "integer"
                },
                "upgrade-next-protocol-vote-before": {
                  "description": "Next protocol round",
                  "type": "integer"
                },
                "upgrade-no-votes": {
                  "description": "No votes cast for consensus upgrade",
                  "type": "integer"
                },
                "upgrade-node-vote": {
                  "description": "This node's upgrade vote",
                  "type": "boolean"
                },
                "upgrade-vote-rounds": {
                  "description": "Total voting rounds for current upgrade",
                  "type": "integer"
                },
                "upgrade-votes": {
                  "description": "Total votes cast for consensus upgrade",
                  "type": "integer"
                },
                "upgrade-votes-required": {
                  "description": "Yes votes required for consensus upgrade",
                  "type": "integer"
                },
                "upgrade-yes-votes": {
                  "description": "Yes votes cast for consensus upgrade",
                  "type": "integer"
                }
              },
              "required": [
                "catchup-time",
                "last-round",
                "last-version",
                "next-version",
                "next-version-round",
                "next-version-supported",
                "stopped-at-unsupported-round",
                "time-since-last-round"
              ],
              "type": "object"
            }
          }
        }
      },
      "ParticipationKeyResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ParticipationKey"
            }
          }
        },
        "description": "A detailed description of a participation ID"
      },
      "ParticipationKeysResponse": {
        "content": {
          "application/json": {
            "schema": {
              "items": {
                "$ref": "#/components/schemas/ParticipationKey"
              },
              "type": "array"
            }
          }
        },
        "description": "A list of participation keys"
      },
      "PendingTransactionsResponse": {
        "content": {
          "application/json": {
            "schema": {
              "description": "PendingTransactions is an array of signed transactions exactly as they were submitted.",
              "properties": {
                "top-transactions": {
                  "description": "An array of signed transaction objects.",
                  "items": {
                    "properties": {},
                    "type": "object",
                    "x-algorand-format": "SignedTransaction"
                  },
                  "type": "array"
                },
                "total-transactions": {
                  "description": "Total number of transactions in the pool.",
                  "type": "integer"
                }
              },
              "required": [
                "top-transactions",
                "total-transactions"
              ],
              "type": "object"
            }
          }
        },
        "description": "A potentially truncated list of transactions currently in the node's transaction pool. You can compute whether or not the list is truncated if the number of elements in the **top-transactions** array is fewer than **total-transactions**."
      },
      "PostParticipationResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "partId": {
                  "description": "encoding of the participation ID.",
                  "type": "string"
                }
              },
              "required": [
                "partId"
              ],
              "type": "object"
            }
          }
        },
        "description": "Participation ID of the submission"
      },
      "PostTransactionsResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "txId": {
                  "description": "encoding of the transaction hash.",
                  "type": "string"
                }
              },
              "required": [
                "txId"
              ],
              "type": "object"
            }
          }
        },
        "description": "Transaction ID of the submission."
      },
      "SimulateResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "eval-overrides": {
                  "$ref": "#/components/schemas/SimulationEvalOverrides"
                },
                "last-round": {
                  "description": "The round immediately preceding this simulation. State changes through this round were used to run this simulation.",
                  "type": "integer"
                },
                "txn-groups": {
                  "description": "A result object for each transaction group that was simulated.",
                  "items": {
                    "$ref": "#/components/schemas/SimulateTransactionGroupResult"
                  },
                  "type": "array"
                },
                "version": {
                  "description": "The version of this response object.",
                  "type": "integer"
                }
              },
              "required": [
                "last-round",
                "txn-groups",
                "version"
              ],
              "type": "object"
            }
          }
        },
        "description": "Result of a transaction group simulation."
      },
      "StateProofResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/StateProof"
            }
          }
        },
        "description": "StateProofResponse wraps the StateProof type in a response."
      },
      "SupplyResponse": {
        "content": {
          "application/json": {
            "schema": {
              "description": "Supply represents the current supply of MicroAlgos in the system",
              "properties": {
                "current_round": {
                  "description": "Round",
                  "type": "integer"
                },
                "online-money": {
                  "description": "OnlineMoney",
                  "type": "integer"
                },
                "total-money": {
                  "description": "TotalMoney",
                  "type": "integer"
                }
              },
              "required": [
                "current_round",
                "online-money",
                "total-money"
              ],
              "type": "object"
            }
          }
        },
        "description": "Supply represents the current supply of MicroAlgos in the system."
      },
      "TransactionGroupLedgerStateDeltasForRoundResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "Deltas": {
                  "items": {
                    "$ref": "#/components/schemas/LedgerStateDeltaForTransactionGroup"
                  },
                  "type": "array"
                }
              },
              "required": [
                "Deltas"
              ],
              "type": "object"
            }
          }
        },
        "description": "Response containing all ledger state deltas for transaction groups, with their associated Ids, in a single round."
      },
      "TransactionParametersResponse": {
        "content": {
          "application/json": {
            "schema": {
              "description": "TransactionParams contains the parameters that help a client construct\na new transaction.",
              "properties": {
                "consensus-version": {
                  "description": "ConsensusVersion indicates the consensus protocol version\nas of LastRound.",
                  "type": "string"
                },
                "fee": {
                  "description": "Fee is the suggested transaction fee\nFee is in units of micro-Algos per byte.\nFee may fall to zero but transactions must still have a fee of\nat least MinTxnFee for the current network protocol.",
                  "type": "integer"
                },
                "genesis-hash": {
                  "description": "GenesisHash is the hash of the genesis block.",
                  "format": "byte",
                  "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                  "type": "string"
                },
                "genesis-id": {
                  "description": "GenesisID is an ID listed in the genesis block.",
                  "type": "string"
                },
                "last-round": {
                  "description": "LastRound indicates the last round seen",
                  "type": "integer"
                },
                "min-fee": {
                  "description": "The minimum transaction fee (not per byte) required for the\ntxn to validate for the current network protocol.",
                  "type": "integer"
                }
              },
              "required": [
                "consensus-version",
                "fee",
                "genesis-hash",
                "genesis-id",
                "last-round",
                "min-fee"
              ],
              "type": "object"
            }
          }
        },
        "description": "TransactionParams contains the parameters that help a client construct a new transaction."
      },
      "TransactionProofResponse": {
        "content": {
          "application/json": {
            "schema": {
              "properties": {
                "hashtype": {
                  "description": "The type of hash function used to create the proof, must be one of: \n* sha512_256 \n* sha256",
                  "enum": [
                    "sha512_256",
                    "sha256"
                  ],
                  "type": "string"
                },
                "idx": {
                  "description": "Index of the transaction in the block's payset.",
                  "type": "integer"
                },
                "proof": {
                  "description": "Proof of transaction membership.",
                  "format": "byte",
                  "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                  "type": "string"
                },
                "stibhash": {
                  "description": "Hash of SignedTxnInBlock for verifying proof.",
                  "format": "byte",
                  "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                  "type": "string"
                },
                "treedepth": {
                  "description": "Represents the depth of the tree that is being proven, i.e. the number of edges from a leaf to the root.",
                  "type": "integer"
                }
              },
              "required": [
                "hashtype",
                "idx",
                "proof",
                "stibhash",
                "treedepth"
              ],
              "type": "object"
            }
          }
        },
        "description": "Proof of transaction in a block."
      },
      "VersionsResponse": {
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Version"
            }
          }
        },
        "description": "VersionsResponse is the response to 'GET /versions'"
      }
    },
    "schemas": {
      "Account": {
        "description": "Account information at a given round.\n\nDefinition:\ndata/basics/userBalance.go : AccountData\n",
        "properties": {
          "address": {
            "description": "the account public key",
            "type": "string"
          },
          "amount": {
            "description": "\\[algo\\] total number of MicroAlgos in the account",
            "type": "integer"
          },
          "amount-without-pending-rewards": {
            "description": "specifies the amount of MicroAlgos in the account, without the pending rewards.",
            "type": "integer"
          },
          "apps-local-state": {
            "description": "\\[appl\\] applications local data stored in this account.\n\nNote the raw object uses `map[int] -> AppLocalState` for this type.",
            "items": {
              "$ref": "#/components/schemas/ApplicationLocalState"
            },
            "type": "array"
          },
          "apps-total-extra-pages": {
            "description": "\\[teap\\] the sum of all extra application program pages for this account.",
            "type": "integer"
          },
          "apps-total-schema": {
            "$ref": "#/components/schemas/ApplicationStateSchema"
          },
          "assets": {
            "description": "\\[asset\\] assets held by this account.\n\nNote the raw object uses `map[int] -> AssetHolding` for this type.",
            "items": {
              "$ref": "#/components/schemas/AssetHolding"
            },
            "type": "array"
          },
          "auth-addr": {
            "description": "\\[spend\\] the address against which signing should be checked. If empty, the address of the current account is used. This field can be updated in any transaction by setting the RekeyTo field.",
            "type": "string",
            "x-algorand-format": "Address"
          },
          "created-apps": {
            "description": "\\[appp\\] parameters of applications created by this account including app global data.\n\nNote: the raw account uses `map[int] -> AppParams` for this type.",
            "items": {
              "$ref": "#/components/schemas/Application"
            },
            "type": "array"
          },
          "created-assets": {
            "description": "\\[apar\\] parameters of assets created by this account.\n\nNote: the raw account uses `map[int] -> Asset` for this type.",
            "items": {
              "$ref": "#/components/schemas/Asset"
            },
            "type": "array"
          },
          "min-balance": {
            "description": "MicroAlgo balance required by the account.\n\nThe requirement grows based on asset and application usage.",
            "type": "integer"
          },
          "participation": {
            "$ref": "#/components/schemas/AccountParticipation"
          },
          "pending-rewards": {
            "description": "amount of MicroAlgos of pending rewards in this account.",
            "type": "integer"
          },
          "reward-base": {
            "description": "\\[ebase\\] used as part of the rewards computation. Only applicable to accounts which are participating.",
            "type": "integer"
          },
          "rewards": {
            "description": "\\[ern\\] total rewards of MicroAlgos the account has received, including pending rewards.",
            "type": "integer"
          },
          "round": {
            "description": "The round for which this information is relevant.",
            "type": "integer"
          },
          "sig-type": {
            "description": "Indicates what type of signature is used by this account, must be one of:\n* sig\n* msig\n* lsig",
            "enum": [
              "sig",
              "msig",
              "lsig"
            ],
            "type": "string"
          },
          "status": {
            "description": "\\[onl\\] delegation status of the account's MicroAlgos\n* Offline - indicates that the associated account is delegated.\n*  Online  - indicates that the associated account used as part of the delegation pool.\n*   NotParticipating - indicates that the associated account is neither a delegator nor a delegate.",
            "type": "string"
          },
          "total-apps-opted-in": {
            "description": "The count of all applications that have been opted in, equivalent to the count of application local data (AppLocalState objects) stored in this account.",
            "type": "integer"
          },
          "total-assets-opted-in": {
            "description": "The count of all assets that have been opted in, equivalent to the count of AssetHolding objects held by this account.",
            "type": "integer"
          },
          "total-box-bytes": {
            "description": "\\[tbxb\\] The total number of bytes used by this account's app's box keys and values.",
            "type": "integer"
          },
          "total-boxes": {
            "description": "\\[tbx\\] The number of existing boxes created by this account's app.",
            "type": "integer"
          },
          "total-created-apps": {
            "description": "The count of all apps (AppParams objects) created by this account.",
            "type": "integer"
          },
          "total-created-assets": {
            "description": "The count of all assets (AssetParams objects) created by this account.",
            "type": "integer"
          }
        },
        "required": [
          "address",
          "amount",
          "amount-without-pending-rewards",
          "min-balance",
          "pending-rewards",
          "rewards",
          "round",
          "status",
          "total-apps-opted-in",
          "total-assets-opted-in",
          "total-created-apps",
          "total-created-assets"
        ],
        "type": "object"
      },
      "AccountParticipation": {
        "description": "AccountParticipation describes the parameters used by this account in consensus protocol.",
        "properties": {
          "selection-participation-key": {
            "description": "\\[sel\\] Selection public key (if any) currently registered for this round.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "state-proof-key": {
            "description": "\\[stprf\\] Root of the state proof key (if any)",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "vote-first-valid": {
            "description": "\\[voteFst\\] First round for which this participation is valid.",
            "type": "integer"
          },
          "vote-key-dilution": {
            "description": "\\[voteKD\\] Number of subkeys in each batch of participation keys.",
            "type": "integer"
          },
          "vote-last-valid": {
            "description": "\\[voteLst\\] Last round for which this participation is valid.",
            "type": "integer"
          },
          "vote-participation-key": {
            "description": "\\[vote\\] root participation public key (if any) currently registered for this round.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "selection-participation-key",
          "vote-first-valid",
          "vote-key-dilution",
          "vote-last-valid",
          "vote-participation-key"
        ],
        "type": "object"
      },
      "AccountStateDelta": {
        "description": "Application state delta.",
        "properties": {
          "address": {
            "type": "string"
          },
          "delta": {
            "$ref": "#/components/schemas/StateDelta"
          }
        },
        "required": [
          "address",
          "delta"
        ],
        "type": "object"
      },
      "Application": {
        "description": "Application index and its parameters",
        "properties": {
          "id": {
            "description": "\\[appidx\\] application index.",
            "type": "integer"
          },
          "params": {
            "$ref": "#/components/schemas/ApplicationParams"
          }
        },
        "required": [
          "id",
          "params"
        ],
        "type": "object"
      },
      "ApplicationLocalState": {
        "description": "Stores local state associated with an application.",
        "properties": {
          "id": {
            "description": "The application which this local state is for.",
            "type": "integer"
          },
          "key-value": {
            "$ref": "#/components/schemas/TealKeyValueStore"
          },
          "schema": {
            "$ref": "#/components/schemas/ApplicationStateSchema"
          }
        },
        "required": [
          "id",
          "schema"
        ],
        "type": "object"
      },
      "ApplicationParams": {
        "description": "Stores the global information associated with an application.",
        "properties": {
          "approval-program": {
            "description": "\\[approv\\] approval program.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string",
            "x-algorand-format": "TEALProgram"
          },
          "clear-state-program": {
            "description": "\\[clearp\\] approval program.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string",
            "x-algorand-format": "TEALProgram"
          },
          "creator": {
            "description": "The address that created this application. This is the address where the parameters and global state for this application can be found.",
            "type": "string",
            "x-algorand-format": "Address"
          },
          "extra-program-pages": {
            "description": "\\[epp\\] the amount of extra program pages available to this app.",
            "type": "integer"
          },
          "global-state": {
            "$ref": "#/components/schemas/TealKeyValueStore"
          },
          "global-state-schema": {
            "$ref": "#/components/schemas/ApplicationStateSchema"
          },
          "local-state-schema": {
            "$ref": "#/components/schemas/ApplicationStateSchema"
          }
        },
        "required": [
          "approval-program",
          "clear-state-program",
          "creator"
        ],
        "type": "object"
      },
      "ApplicationStateSchema": {
        "description": "Specifies maximums on the number of each type that may be stored.",
        "properties": {
          "num-byte-slice": {
            "description": "\\[nbs\\] num of byte slices.",
            "type": "integer"
          },
          "num-uint": {
            "description": "\\[nui\\] num of uints.",
            "type": "integer"
          }
        },
        "required": [
          "num-byte-slice",
          "num-uint"
        ],
        "type": "object"
      },
      "Asset": {
        "description": "Specifies both the unique identifier and the parameters for an asset",
        "properties": {
          "index": {
            "description": "unique asset identifier",
            "type": "integer"
          },
          "params": {
            "$ref": "#/components/schemas/AssetParams"
          }
        },
        "required": [
          "index",
          "params"
        ],
        "type": "object"
      },
      "AssetHolding": {
        "description": "Describes an asset held by an account.\n\nDefinition:\ndata/basics/userBalance.go : AssetHolding",
        "properties": {
          "amount": {
            "description": "\\[a\\] number of units held.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "asset-id": {
            "description": "Asset ID of the holding.",
            "type": "integer",
            "x-go-name": "AssetID"
          },
          "is-frozen": {
            "description": "\\[f\\] whether or not the holding is frozen.",
            "type": "boolean"
          }
        },
        "required": [
          "amount",
          "asset-id",
          "is-frozen"
        ],
        "type": "object"
      },
      "AssetParams": {
        "description": "AssetParams specifies the parameters for an asset.\n\n\\[apar\\] when part of an AssetConfig transaction.\n\nDefinition:\ndata/transactions/asset.go : AssetParams",
        "properties": {
          "clawback": {
            "description": "\\[c\\] Address of account used to clawback holdings of this asset.  If empty, clawback is not permitted.",
            "type": "string"
          },
          "creator": {
            "description": "The address that created this asset. This is the address where the parameters for this asset can be found, and also the address where unwanted asset units can be sent in the worst case.",
            "type": "string"
          },
          "decimals": {
            "description": "\\[dc\\] The number of digits to use after the decimal point when displaying this asset. If 0, the asset is not divisible. If 1, the base unit of the asset is in tenths. If 2, the base unit of the asset is in hundredths, and so on. This value must be between 0 and 19 (inclusive).",
            "maximum": 19,
            "minimum": 0,
            "type": "integer"
          },
          "default-frozen": {
            "description": "\\[df\\] Whether holdings of this asset are frozen by default.",
            "type": "boolean"
          },
          "freeze": {
            "description": "\\[f\\] Address of account used to freeze holdings of this asset.  If empty, freezing is not permitted.",
            "type": "string"
          },
          "manager": {
            "description": "\\[m\\] Address of account used to manage the keys of this asset and to destroy it.",
            "type": "string"
          },
          "metadata-hash": {
            "description": "\\[am\\] A commitment to some unspecified asset metadata. The format of this metadata is up to the application.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "name": {
            "description": "\\[an\\] Name of this asset, as supplied by the creator. Included only when the asset name is composed of printable utf-8 characters.",
            "type": "string"
          },
          "name-b64": {
            "description": "Base64 encoded name of this asset, as supplied by the creator.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "reserve": {
            "description": "\\[r\\] Address of account holding reserve (non-minted) units of this asset.",
            "type": "string"
          },
          "total": {
            "description": "\\[t\\] The total number of units of this asset.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "unit-name": {
            "description": "\\[un\\] Name of a unit of this asset, as supplied by the creator. Included only when the name of a unit of this asset is composed of printable utf-8 characters.",
            "type": "string"
          },
          "unit-name-b64": {
            "description": "Base64 encoded name of a unit of this asset, as supplied by the creator.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "url": {
            "description": "\\[au\\] URL where more information about the asset can be retrieved. Included only when the URL is composed of printable utf-8 characters.",
            "type": "string"
          },
          "url-b64": {
            "description": "Base64 encoded URL where more information about the asset can be retrieved.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "creator",
          "decimals",
          "total"
        ],
        "type": "object"
      },
      "Box": {
        "description": "Box name and its content.",
        "properties": {
          "name": {
            "description": "\\[name\\] box name, base64 encoded",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "round": {
            "description": "The round for which this information is relevant",
            "type": "integer"
          },
          "value": {
            "description": "\\[value\\] box value, base64 encoded.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "name",
          "round",
          "value"
        ],
        "type": "object"
      },
      "BoxDescriptor": {
        "description": "Box descriptor describes a Box.",
        "properties": {
          "name": {
            "description": "Base64 encoded box name",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "name"
        ],
        "type": "object"
      },
      "BuildVersion": {
        "properties": {
          "branch": {
            "type": "string"
          },
          "build_number": {
            "format": "int64",
            "type": "integer"
          },
          "channel": {
            "type": "string"
          },
          "commit_hash": {
            "type": "string"
          },
          "major": {
            "format": "int64",
            "type": "integer"
          },
          "minor": {
            "format": "int64",
            "type": "integer"
          }
        },
        "required": [
          "branch",
          "build_number",
          "channel",
          "commit_hash",
          "major",
          "minor"
        ],
        "title": "BuildVersion contains the current algod build version information.",
        "type": "object"
      },
      "DryrunRequest": {
        "description": "Request data type for dryrun endpoint. Given the Transactions and simulated ledger state upload, run TEAL scripts and return debugging information.",
        "properties": {
          "accounts": {
            "items": {
              "$ref": "#/components/schemas/Account"
            },
            "type": "array"
          },
          "apps": {
            "items": {
              "$ref": "#/components/schemas/Application"
            },
            "type": "array"
          },
          "latest-timestamp": {
            "description": "LatestTimestamp is available to some TEAL scripts. Defaults to the latest confirmed timestamp this algod is attached to.",
            "format": "int64",
            "type": "integer"
          },
          "protocol-version": {
            "description": "ProtocolVersion specifies a specific version string to operate under, otherwise whatever the current protocol of the network this algod is running in.",
            "type": "string"
          },
          "round": {
            "description": "Round is available to some TEAL scripts. Defaults to the current round on the network this algod is attached to.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "sources": {
            "items": {
              "$ref": "#/components/schemas/DryrunSource"
            },
            "type": "array"
          },
          "txns": {
            "items": {
              "description": "SignedTxn object. Must be canonically encoded.",
              "format": "json",
              "type": "string",
              "x-algorand-format": "SignedTransaction"
            },
            "type": "array"
          }
        },
        "required": [
          "accounts",
          "apps",
          "latest-timestamp",
          "protocol-version",
          "round",
          "sources",
          "txns"
        ],
        "type": "object"
      },
      "DryrunSource": {
        "description": "DryrunSource is TEAL source text that gets uploaded, compiled, and inserted into transactions or application state.",
        "properties": {
          "app-index": {
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "field-name": {
            "description": "FieldName is what kind of sources this is. If lsig then it goes into the transactions[this.TxnIndex].LogicSig. If approv or clearp it goes into the Approval Program or Clear State Program of application[this.AppIndex].",
            "type": "string"
          },
          "source": {
            "type": "string"
          },
          "txn-index": {
            "type": "integer"
          }
        },
        "required": [
          "app-index",
          "field-name",
          "source",
          "txn-index"
        ],
        "type": "object"
      },
      "DryrunState": {
        "description": "Stores the TEAL eval step data",
        "properties": {
          "error": {
            "description": "Evaluation error if any",
            "type": "string"
          },
          "line": {
            "description": "Line number",
            "type": "integer"
          },
          "pc": {
            "description": "Program counter",
            "type": "integer"
          },
          "scratch": {
            "items": {
              "$ref": "#/components/schemas/TealValue"
            },
            "type": "array"
          },
          "stack": {
            "items": {
              "$ref": "#/components/schemas/TealValue"
            },
            "type": "array"
          }
        },
        "required": [
          "line",
          "pc",
          "stack"
        ],
        "type": "object"
      },
      "DryrunTxnResult": {
        "description": "DryrunTxnResult contains any LogicSig or ApplicationCall program debug information and state updates from a dryrun.",
        "properties": {
          "app-call-messages": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "app-call-trace": {
            "items": {
              "$ref": "#/components/schemas/DryrunState"
            },
            "type": "array"
          },
          "budget-added": {
            "description": "Budget added during execution of app call transaction.",
            "type": "integer"
          },
          "budget-consumed": {
            "description": "Budget consumed during execution of app call transaction.",
            "type": "integer"
          },
          "disassembly": {
            "description": "Disassembled program line by line.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "global-delta": {
            "$ref": "#/components/schemas/StateDelta"
          },
          "local-deltas": {
            "items": {
              "$ref": "#/components/schemas/AccountStateDelta"
            },
            "type": "array"
          },
          "logic-sig-disassembly": {
            "description": "Disassembled lsig program line by line.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "logic-sig-messages": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "logic-sig-trace": {
            "items": {
              "$ref": "#/components/schemas/DryrunState"
            },
            "type": "array"
          },
          "logs": {
            "items": {
              "format": "byte",
              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "disassembly"
        ],
        "type": "object"
      },
      "ErrorResponse": {
        "description": "An error response with optional data field.",
        "properties": {
          "data": {
            "properties": {},
            "type": "object"
          },
          "message": {
            "type": "string"
          }
        },
        "required": [
          "message"
        ],
        "type": "object"
      },
      "EvalDelta": {
        "description": "Represents a TEAL value delta.",
        "properties": {
          "action": {
            "description": "\\[at\\] delta action.",
            "type": "integer"
          },
          "bytes": {
            "description": "\\[bs\\] bytes value.",
            "type": "string"
          },
          "uint": {
            "description": "\\[ui\\] uint value.",
            "type": "integer",
            "x-algorand-format": "uint64"
          }
        },
        "required": [
          "action"
        ],
        "type": "object"
      },
      "EvalDeltaKeyValue": {
        "description": "Key-value pairs for StateDelta.",
        "properties": {
          "key": {
            "type": "string"
          },
          "value": {
            "$ref": "#/components/schemas/EvalDelta"
          }
        },
        "required": [
          "key",
          "value"
        ],
        "type": "object"
      },
      "KvDelta": {
        "description": "A single Delta containing the key, the previous value and the current value for a single round.",
        "properties": {
          "key": {
            "description": "The key, base64 encoded.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "value": {
            "description": "The new value of the KV store entry, base64 encoded.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "type": "object"
      },
      "LedgerStateDelta": {
        "description": "Ledger StateDelta object",
        "type": "object",
        "x-algorand-format": "StateDelta"
      },
      "LedgerStateDeltaForTransactionGroup": {
        "description": "Contains a ledger delta for a single transaction group",
        "properties": {
          "Delta": {
            "$ref": "#/components/schemas/LedgerStateDelta"
          },
          "Ids": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "Delta",
          "Ids"
        ],
        "type": "object"
      },
      "LightBlockHeaderProof": {
        "description": "Proof of membership and position of a light block header.",
        "properties": {
          "index": {
            "description": "The index of the light block header in the vector commitment tree",
            "type": "integer"
          },
          "proof": {
            "description": "The encoded proof.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "treedepth": {
            "description": "Represents the depth of the tree that is being proven, i.e. the number of edges from a leaf to the root.",
            "type": "integer"
          }
        },
        "required": [
          "index",
          "proof",
          "treedepth"
        ],
        "type": "object"
      },
      "ParticipationKey": {
        "description": "Represents a participation key used by the node.",
        "properties": {
          "address": {
            "description": "Address the key was generated for.",
            "type": "string",
            "x-algorand-format": "Address"
          },
          "effective-first-valid": {
            "description": "When registered, this is the first round it may be used.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "effective-last-valid": {
            "description": "When registered, this is the last round it may be used.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "id": {
            "description": "The key's ParticipationID.",
            "type": "string"
          },
          "key": {
            "$ref": "#/components/schemas/AccountParticipation"
          },
          "last-block-proposal": {
            "description": "Round when this key was last used to propose a block.",
            "type": "integer"
          },
          "last-state-proof": {
            "description": "Round when this key was last used to generate a state proof.",
            "type": "integer"
          },
          "last-vote": {
            "description": "Round when this key was last used to vote.",
            "type": "integer"
          }
        },
        "required": [
          "address",
          "id",
          "key"
        ],
        "type": "object"
      },
      "PendingTransactionResponse": {
        "description": "Details about a pending transaction. If the transaction was recently confirmed, includes confirmation details like the round and reward details.",
        "properties": {
          "application-index": {
            "description": "The application index if the transaction was found and it created an application.",
            "type": "integer"
          },
          "asset-closing-amount": {
            "description": "The number of the asset's unit that were transferred to the close-to address.",
            "type": "integer"
          },
          "asset-index": {
            "description": "The asset index if the transaction was found and it created an asset.",
            "type": "integer"
          },
          "close-rewards": {
            "description": "Rewards in microalgos applied to the close remainder to account.",
            "type": "integer"
          },
          "closing-amount": {
            "description": "Closing amount for the transaction.",
            "type": "integer"
          },
          "confirmed-round": {
            "description": "The round where this transaction was confirmed, if present.",
            "type": "integer"
          },
          "global-state-delta": {
            "$ref": "#/components/schemas/StateDelta"
          },
          "inner-txns": {
            "description": "Inner transactions produced by application execution.",
            "items": {
              "$ref": "#/components/schemas/PendingTransactionResponse"
            },
            "type": "array"
          },
          "local-state-delta": {
            "description": "Local state key/value changes for the application being executed by this transaction.",
            "items": {
              "$ref": "#/components/schemas/AccountStateDelta"
            },
            "type": "array"
          },
          "logs": {
            "description": "Logs for the application being executed by this transaction.",
            "items": {
              "format": "byte",
              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
              "type": "string"
            },
            "type": "array"
          },
          "pool-error": {
            "description": "Indicates that the transaction was kicked out of this node's transaction pool (and specifies why that happened).  An empty string indicates the transaction wasn't kicked out of this node's txpool due to an error.\n",
            "type": "string"
          },
          "receiver-rewards": {
            "description": "Rewards in microalgos applied to the receiver account.",
            "type": "integer"
          },
          "sender-rewards": {
            "description": "Rewards in microalgos applied to the sender account.",
            "type": "integer"
          },
          "txn": {
            "description": "The raw signed transaction.",
            "properties": {},
            "type": "object",
            "x-algorand-format": "SignedTransaction"
          }
        },
        "required": [
          "pool-error",
          "txn"
        ],
        "type": "object"
      },
      "SimulateRequest": {
        "description": "Request type for simulation endpoint.",
        "properties": {
          "allow-empty-signatures": {
            "description": "Allow transactions without signatures to be simulated as if they had correct signatures.",
            "type": "boolean"
          },
          "allow-more-logging": {
            "description": "Lifts limits on log opcode usage during simulation.",
            "type": "boolean"
          },
          "extra-opcode-budget": {
            "description": "Applies extra opcode budget during simulation for each transaction group.",
            "type": "integer"
          },
          "txn-groups": {
            "description": "The transaction groups to simulate.",
            "items": {
              "$ref": "#/components/schemas/SimulateRequestTransactionGroup"
            },
            "type": "array"
          }
        },
        "required": [
          "txn-groups"
        ],
        "type": "object"
      },
      "SimulateRequestTransactionGroup": {
        "description": "A transaction group to simulate.",
        "properties": {
          "txns": {
            "description": "An atomic transaction group.",
            "items": {
              "description": "SignedTxn object. Must be canonically encoded.",
              "format": "json",
              "type": "string",
              "x-algorand-format": "SignedTransaction"
            },
            "type": "array"
          }
        },
        "required": [
          "txns"
        ],
        "type": "object"
      },
      "SimulateTransactionGroupResult": {
        "description": "Simulation result for an atomic transaction group",
        "properties": {
          "app-budget-added": {
            "description": "Total budget added during execution of app calls in the transaction group.",
            "type": "integer"
          },
          "app-budget-consumed": {
            "description": "Total budget consumed during execution of app calls in the transaction group.",
            "type": "integer"
          },
          "failed-at": {
            "description": "If present, indicates which transaction in this group caused the failure. This array represents the path to the failing transaction. Indexes are zero based, the first element indicates the top-level transaction, and successive elements indicate deeper inner transactions.",
            "items": {
              "type": "integer"
            },
            "type": "array"
          },
          "failure-message": {
            "description": "If present, indicates that the transaction group failed and specifies why that happened",
            "type": "string"
          },
          "txn-results": {
            "description": "Simulation result for individual transactions",
            "items": {
              "$ref": "#/components/schemas/SimulateTransactionResult"
            },
            "type": "array"
          }
        },
        "required": [
          "txn-results"
        ],
        "type": "object"
      },
      "SimulateTransactionResult": {
        "description": "Simulation result for an individual transaction",
        "properties": {
          "app-budget-consumed": {
            "description": "Budget used during execution of an app call transaction. This value includes budged used by inner app calls spawned by this transaction.",
            "type": "integer"
          },
          "logic-sig-budget-consumed": {
            "description": "Budget used during execution of a logic sig transaction.",
            "type": "integer"
          },
          "txn-result": {
            "$ref": "#/components/schemas/PendingTransactionResponse"
          }
        },
        "required": [
          "txn-result"
        ],
        "type": "object"
      },
      "SimulationEvalOverrides": {
        "description": "The set of parameters and limits override during simulation. If this set of parameters is present, then evaluation parameters may differ from standard evaluation in certain ways.",
        "properties": {
          "allow-empty-signatures": {
            "description": "If true, transactions without signatures are allowed and simulated as if they were properly signed.",
            "type": "boolean"
          },
          "extra-opcode-budget": {
            "description": "The extra opcode budget added to each transaction group during simulation",
            "type": "integer"
          },
          "max-log-calls": {
            "description": "The maximum log calls one can make during simulation",
            "type": "integer"
          },
          "max-log-size": {
            "description": "The maximum byte number to log during simulation",
            "type": "integer"
          }
        },
        "type": "object"
      },
      "StateDelta": {
        "description": "Application state delta.",
        "items": {
          "$ref": "#/components/schemas/EvalDeltaKeyValue"
        },
        "type": "array"
      },
      "StateProof": {
        "description": "Represents a state proof and its corresponding message",
        "properties": {
          "Message": {
            "$ref": "#/components/schemas/StateProofMessage"
          },
          "StateProof": {
            "description": "The encoded StateProof for the message.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "Message",
          "StateProof"
        ],
        "type": "object"
      },
      "StateProofMessage": {
        "description": "Represents the message that the state proofs are attesting to.",
        "properties": {
          "BlockHeadersCommitment": {
            "description": "The vector commitment root on all light block headers within a state proof interval.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "FirstAttestedRound": {
            "description": "The first round the message attests to.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "LastAttestedRound": {
            "description": "The last round the message attests to.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "LnProvenWeight": {
            "description": "An integer value representing the natural log of the proven weight with 16 bits of precision. This value would be used to verify the next state proof.",
            "type": "integer",
            "x-algorand-format": "uint64"
          },
          "VotersCommitment": {
            "description": "The vector commitment root of the top N accounts to sign the next StateProof.",
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          }
        },
        "required": [
          "BlockHeadersCommitment",
          "FirstAttestedRound",
          "LastAttestedRound",
          "LnProvenWeight",
          "VotersCommitment"
        ],
        "type": "object"
      },
      "TealKeyValue": {
        "description": "Represents a key-value pair in an application store.",
        "properties": {
          "key": {
            "type": "string"
          },
          "value": {
            "$ref": "#/components/schemas/TealValue"
          }
        },
        "required": [
          "key",
          "value"
        ],
        "type": "object"
      },
      "TealKeyValueStore": {
        "description": "Represents a key-value store for use in an application.",
        "items": {
          "$ref": "#/components/schemas/TealKeyValue"
        },
        "type": "array"
      },
      "TealValue": {
        "description": "Represents a TEAL value.",
        "properties": {
          "bytes": {
            "description": "\\[tb\\] bytes value.",
            "type": "string"
          },
          "type": {
            "description": "\\[tt\\] value type. Value `1` refers to **bytes**, value `2` refers to **uint**",
            "type": "integer"
          },
          "uint": {
            "description": "\\[ui\\] uint value.",
            "type": "integer",
            "x-algorand-format": "uint64"
          }
        },
        "required": [
          "bytes",
          "type",
          "uint"
        ],
        "type": "object"
      },
      "Version": {
        "description": "algod version information.",
        "properties": {
          "build": {
            "$ref": "#/components/schemas/BuildVersion"
          },
          "genesis_hash_b64": {
            "format": "byte",
            "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
            "type": "string"
          },
          "genesis_id": {
            "type": "string"
          },
          "versions": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "build",
          "genesis_hash_b64",
          "genesis_id",
          "versions"
        ],
        "title": "Version contains the current algod version.",
        "type": "object"
      }
    }
  },
  "info": {
    "contact": {
      "name": "Algonode.io",
      "url": "https://algonode.io/contact"
    },
    "description": "API endpoint for algod operations.",
    "title": "Algod REST API.",
    "version": "3.16"
  },
  "openapi": "3.0.1",
  "paths": {
    "/genesis": {
      "get": {
        "description": "Returns the entire genesis file in json.",
        "operationId": "GetGenesis",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "The genesis file in json."
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Gets the genesis information.",
        "tags": [
          "public",
          "common"
        ]
      }
    },
    "/health": {
      "get": {
        "operationId": "HealthCheck",
        "responses": {
          "200": {
            "content": {},
            "description": "OK."
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Returns OK if healthy.",
        "tags": [
          "public",
          "common"
        ]
      }
    },
    "/metrics": {
      "get": {
        "operationId": "Metrics",
        "responses": {
          "200": {
            "content": {},
            "description": "text with \\#-comments and key:value lines"
          },
          "404": {
            "content": {},
            "description": "metrics were compiled out"
          }
        },
        "summary": "Return metrics about algod functioning.",
        "tags": [
          "public",
          "common"
        ]
      }
    },
    "/ready": {
      "get": {
        "operationId": "GetReady",
        "responses": {
          "200": {
            "content": {},
            "description": "OK."
          },
          "500": {
            "content": {},
            "description": "Internal Error"
          },
          "503": {
            "content": {},
            "description": "Node not ready yet"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Returns OK if healthy and fully caught up.",
        "tags": [
          "public",
          "common"
        ]
      }
    },
    "/swagger.json": {
      "get": {
        "description": "Returns the entire swagger spec in json.",
        "operationId": "SwaggerJSON",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "The current swagger spec"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Gets the current swagger spec.",
        "tags": [
          "public",
          "common"
        ]
      }
    },
    "/v2/accounts/{address}": {
      "get": {
        "description": "Given a specific account public key, this call returns the accounts status, balance and spendable amounts",
        "operationId": "AccountInformation",
        "parameters": [
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          },
          {
            "description": "An account public key",
            "in": "path",
            "name": "address",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]{58}",
              "type": "string"
            }
          },
          {
            "description": "When set to `all` will exclude asset holdings, application local state, created asset parameters, any created application parameters. Defaults to `none`.",
            "in": "query",
            "name": "exclude",
            "schema": {
              "enum": [
                "all",
                "none"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Account"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/Account"
                }
              }
            },
            "description": "AccountResponse wraps the Account type in a response."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get account information.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/accounts/{address}/applications/{application-id}": {
      "get": {
        "description": "Given a specific account public key and application ID, this call returns the account's application local state and global state (AppLocalState and AppParams, if either exists). Global state will only be returned if the provided address is the application's creator.",
        "operationId": "AccountApplicationInformation",
        "parameters": [
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          },
          {
            "description": "An account public key",
            "in": "path",
            "name": "address",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]{58}",
              "type": "string"
            }
          },
          {
            "description": "An application identifier",
            "in": "path",
            "name": "application-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "app-local-state": {
                      "$ref": "#/components/schemas/ApplicationLocalState"
                    },
                    "created-app": {
                      "$ref": "#/components/schemas/ApplicationParams"
                    },
                    "round": {
                      "description": "The round for which this information is relevant.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "round"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "properties": {
                    "app-local-state": {
                      "$ref": "#/components/schemas/ApplicationLocalState"
                    },
                    "created-app": {
                      "$ref": "#/components/schemas/ApplicationParams"
                    },
                    "round": {
                      "description": "The round for which this information is relevant.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "round"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "AccountApplicationResponse describes the account's application local state and global state (AppLocalState and AppParams, if either exists) for a specific application ID. Global state will only be returned if the provided address is the application's creator."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Malformed address or application ID"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get account information about a given app.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/accounts/{address}/assets/{asset-id}": {
      "get": {
        "description": "Given a specific account public key and asset ID, this call returns the account's asset holding and asset parameters (if either exist). Asset parameters will only be returned if the provided address is the asset's creator.",
        "operationId": "AccountAssetInformation",
        "parameters": [
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          },
          {
            "description": "An account public key",
            "in": "path",
            "name": "address",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]{58}",
              "type": "string"
            }
          },
          {
            "description": "An asset identifier",
            "in": "path",
            "name": "asset-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "asset-holding": {
                      "$ref": "#/components/schemas/AssetHolding"
                    },
                    "created-asset": {
                      "$ref": "#/components/schemas/AssetParams"
                    },
                    "round": {
                      "description": "The round for which this information is relevant.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "round"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "properties": {
                    "asset-holding": {
                      "$ref": "#/components/schemas/AssetHolding"
                    },
                    "created-asset": {
                      "$ref": "#/components/schemas/AssetParams"
                    },
                    "round": {
                      "description": "The round for which this information is relevant.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "round"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "AccountAssetResponse describes the account's asset holding and asset parameters (if either exist) for a specific asset ID. Asset parameters will only be returned if the provided address is the asset's creator."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Malformed address or asset ID"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get account information about a given asset.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/accounts/{address}/transactions/pending": {
      "get": {
        "description": "Get the list of pending transactions by address, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.\n",
        "operationId": "GetPendingTransactionsByAddress",
        "parameters": [
          {
            "description": "An account public key",
            "in": "path",
            "name": "address",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]{58}",
              "type": "string"
            }
          },
          {
            "description": "Truncated number of transactions to display. If max=0, returns all pending txns.",
            "in": "query",
            "name": "max",
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "PendingTransactions is an array of signed transactions exactly as they were submitted.",
                  "properties": {
                    "top-transactions": {
                      "description": "An array of signed transaction objects.",
                      "items": {
                        "properties": {},
                        "type": "object",
                        "x-algorand-format": "SignedTransaction"
                      },
                      "type": "array"
                    },
                    "total-transactions": {
                      "description": "Total number of transactions in the pool.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "top-transactions",
                    "total-transactions"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "description": "PendingTransactions is an array of signed transactions exactly as they were submitted.",
                  "properties": {
                    "top-transactions": {
                      "description": "An array of signed transaction objects.",
                      "items": {
                        "properties": {},
                        "type": "object",
                        "x-algorand-format": "SignedTransaction"
                      },
                      "type": "array"
                    },
                    "total-transactions": {
                      "description": "Total number of transactions in the pool.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "top-transactions",
                    "total-transactions"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "A potentially truncated list of transactions currently in the node's transaction pool. You can compute whether or not the list is truncated if the number of elements in the **top-transactions** array is fewer than **total-transactions**."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Max must be a non-negative integer"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a list of unconfirmed transactions currently in the transaction pool by address.",
        "tags": [
          "public",
          "participating"
        ]
      }
    },
    "/v2/applications/{application-id}": {
      "get": {
        "description": "Given a application ID, it returns application information including creator, approval and clear programs, global and local schemas, and global state.",
        "operationId": "GetApplicationByID",
        "parameters": [
          {
            "description": "An application identifier",
            "in": "path",
            "name": "application-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Application"
                }
              }
            },
            "description": "Application information"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Application Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get application information.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/applications/{application-id}/box": {
      "get": {
        "description": "Given an application ID and box name, it returns the round, box name, and value (each base64 encoded). Box names must be in the goal app call arg encoding form 'encoding:value'. For ints, use the form 'int:1234'. For raw bytes, use the form 'b64:A=='. For printable strings, use the form 'str:hello'. For addresses, use the form 'addr:XYZ...'.",
        "operationId": "GetApplicationBoxByName",
        "parameters": [
          {
            "description": "An application identifier",
            "in": "path",
            "name": "application-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "A box name, in the goal app call arg form 'encoding:value'. For ints, use the form 'int:1234'. For raw bytes, use the form 'b64:A=='. For printable strings, use the form 'str:hello'. For addresses, use the form 'addr:XYZ...'.",
            "in": "query",
            "name": "name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Box"
                }
              }
            },
            "description": "Box information"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Box Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get box information for a given application.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/applications/{application-id}/boxes": {
      "get": {
        "description": "Given an application ID, return all Box names. No particular ordering is guaranteed. Request fails when client or server-side configured limits prevent returning all Box names.",
        "operationId": "GetApplicationBoxes",
        "parameters": [
          {
            "description": "An application identifier",
            "in": "path",
            "name": "application-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "Max number of box names to return. If max is not set, or max == 0, returns all box-names.",
            "in": "query",
            "name": "max",
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "boxes": {
                      "items": {
                        "$ref": "#/components/schemas/BoxDescriptor"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "boxes"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Box names of an application"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get all box names for a given application.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/assets/{asset-id}": {
      "get": {
        "description": "Given a asset ID, it returns asset information including creator, name, total supply and special addresses.",
        "operationId": "GetAssetByID",
        "parameters": [
          {
            "description": "An asset identifier",
            "in": "path",
            "name": "asset-id",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Asset"
                }
              }
            },
            "description": "Asset information"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Application Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get asset information.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/blocks/{round}": {
      "get": {
        "operationId": "GetBlock",
        "parameters": [
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          },
          {
            "description": "The round from which to fetch block information.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "block": {
                      "description": "Block header data.",
                      "properties": {},
                      "type": "object",
                      "x-algorand-format": "BlockHeader"
                    },
                    "cert": {
                      "description": "Optional certificate object. This is only included when the format is set to message pack.",
                      "properties": {},
                      "type": "object",
                      "x-algorand-format": "BlockCertificate"
                    }
                  },
                  "required": [
                    "block"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "properties": {
                    "block": {
                      "description": "Block header data.",
                      "properties": {},
                      "type": "object",
                      "x-algorand-format": "BlockHeader"
                    },
                    "cert": {
                      "description": "Optional certificate object. This is only included when the format is set to message pack.",
                      "properties": {},
                      "type": "object",
                      "x-algorand-format": "BlockCertificate"
                    }
                  },
                  "required": [
                    "block"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Encoded block object."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request - Non integer number"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "None existing block "
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get the block for the given round.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/blocks/{round}/hash": {
      "get": {
        "operationId": "GetBlockHash",
        "parameters": [
          {
            "description": "The round from which to fetch block hash information.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "blockHash": {
                      "description": "Block header hash.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "blockHash"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Hash of a block header."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request - Non integer number"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "None existing block "
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get the block hash for the block on the given round.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/blocks/{round}/lightheader/proof": {
      "get": {
        "operationId": "GetLightBlockHeaderProof",
        "parameters": [
          {
            "description": "The round to which the light block header belongs.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LightBlockHeaderProof"
                }
              }
            },
            "description": "Proof of a light block header."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Could not create proof since some data is missing"
          },
          "408": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "timed out on request"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Gets a proof for a given light block header inside a state proof commitment",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/blocks/{round}/transactions/{txid}/proof": {
      "get": {
        "operationId": "GetTransactionProof",
        "parameters": [
          {
            "description": "The round in which the transaction appears.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "The transaction ID for which to generate a proof.",
            "in": "path",
            "name": "txid",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]+",
              "type": "string"
            }
          },
          {
            "description": "The type of hash function used to create the proof, must be one of: \n* sha512_256 \n* sha256",
            "in": "query",
            "name": "hashtype",
            "schema": {
              "enum": [
                "sha512_256",
                "sha256"
              ],
              "type": "string"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "hashtype": {
                      "description": "The type of hash function used to create the proof, must be one of: \n* sha512_256 \n* sha256",
                      "enum": [
                        "sha512_256",
                        "sha256"
                      ],
                      "type": "string"
                    },
                    "idx": {
                      "description": "Index of the transaction in the block's payset.",
                      "type": "integer"
                    },
                    "proof": {
                      "description": "Proof of transaction membership.",
                      "format": "byte",
                      "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                      "type": "string"
                    },
                    "stibhash": {
                      "description": "Hash of SignedTxnInBlock for verifying proof.",
                      "format": "byte",
                      "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                      "type": "string"
                    },
                    "treedepth": {
                      "description": "Represents the depth of the tree that is being proven, i.e. the number of edges from a leaf to the root.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "hashtype",
                    "idx",
                    "proof",
                    "stibhash",
                    "treedepth"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Proof of transaction in a block."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Malformed round number or transaction ID"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Non-existent block or transaction"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal error, including protocol not supporting proofs."
          },
          "default": {
            "content": {},
            "description": "Unknown error"
          }
        },
        "summary": "Get a proof for a transaction in a block.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/catchup/{catchpoint}": {
      "delete": {
        "description": "Given a catchpoint, it aborts catching up to this catchpoint",
        "operationId": "AbortCatchup",
        "parameters": [
          {
            "description": "A catch point",
            "in": "path",
            "name": "catchpoint",
            "required": true,
            "schema": {
              "format": "catchpoint",
              "pattern": "[0-9]{1,10}#[A-Z0-9]{1,53}",
              "type": "string",
              "x-algorand-format": "Catchpoint String"
            },
            "x-algorand-format": "Catchpoint String"
          }
        ],
        "responses": {
          "200": {
            "description": "An catchpoint abort response.",
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "catchup-message": {
                      "description": "Catchup abort response string",
                      "type": "string"
                    }
                  },
                  "required": [
                    "catchup-message"
                  ],
                  "type": "object"
                }
              }
            }
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Aborts a catchpoint catchup.",
        "tags": [
          "private",
          "nonparticipating"
        ]
      },
      "post": {
        "description": "Given a catchpoint, it starts catching up to this catchpoint",
        "operationId": "StartCatchup",
        "parameters": [
          {
            "description": "A catch point",
            "in": "path",
            "name": "catchpoint",
            "required": true,
            "schema": {
              "format": "catchpoint",
              "pattern": "[0-9]{1,10}#[A-Z0-9]{1,53}",
              "type": "string",
              "x-algorand-format": "Catchpoint String"
            },
            "x-algorand-format": "Catchpoint String"
          }
        ],
        "responses": {
          "200": {
            "description": "An catchpoint start response.",
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "catchup-message": {
                      "description": "Catchup start response string",
                      "type": "string"
                    }
                  },
                  "required": [
                    "catchup-message"
                  ],
                  "type": "object"
                }
              }
            }
          },
          "201": {
            "description": "An catchpoint start response.",
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "catchup-message": {
                      "description": "Catchup start response string",
                      "type": "string"
                    }
                  },
                  "required": [
                    "catchup-message"
                  ],
                  "type": "object"
                }
              }
            }
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Starts a catchpoint catchup.",
        "tags": [
          "private",
          "nonparticipating"
        ]
      }
    },
    "/v2/deltas/txn/group/{id}": {
      "get": {
        "description": "Get a ledger delta for a given transaction group.",
        "operationId": "GetLedgerStateDeltaForTransactionGroup",
        "parameters": [
          {
            "description": "A transaction ID, or transaction group ID",
            "in": "path",
            "name": "id",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]+",
              "type": "string"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LedgerStateDelta"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/LedgerStateDelta"
                }
              }
            },
            "description": "Response containing a ledger state delta for a single transaction group."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Could not find a delta for transaction ID or group ID"
          },
          "408": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "timed out on request"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "501": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Not Implemented"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a LedgerStateDelta object for a given transaction group",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/deltas/{round}": {
      "get": {
        "description": "Get ledger deltas for a round.",
        "operationId": "GetLedgerStateDelta",
        "parameters": [
          {
            "description": "The round for which the deltas are desired.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LedgerStateDelta"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/LedgerStateDelta"
                }
              }
            },
            "description": "Contains ledger deltas"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Could not find a delta for round"
          },
          "408": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "timed out on request"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a LedgerStateDelta object for a given round",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/deltas/{round}/txn/group": {
      "get": {
        "description": "Get ledger deltas for transaction groups in a given round.",
        "operationId": "GetTransactionGroupLedgerStateDeltasForRound",
        "parameters": [
          {
            "description": "The round for which the deltas are desired.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "Deltas": {
                      "items": {
                        "$ref": "#/components/schemas/LedgerStateDeltaForTransactionGroup"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "Deltas"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "properties": {
                    "Deltas": {
                      "items": {
                        "$ref": "#/components/schemas/LedgerStateDeltaForTransactionGroup"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "Deltas"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Response containing all ledger state deltas for transaction groups, with their associated Ids, in a single round."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Could not find deltas for round"
          },
          "408": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "timed out on request"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "501": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Not Implemented"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get LedgerStateDelta objects for all transaction groups in a given round",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/devmode/blocks/offset": {
      "get": {
        "description": "Gets the current timestamp offset.",
        "operationId": "GetBlockTimeStampOffset",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "offset": {
                      "description": "Timestamp offset in seconds.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "offset"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Response containing the timestamp offset in seconds"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "TimeStamp offset not set."
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Returns the timestamp offset. Timestamp offsets can only be set in dev mode.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/devmode/blocks/offset/{offset}": {
      "post": {
        "description": "Sets the timestamp offset (seconds) for blocks in dev mode. Providing an offset of 0 will unset this value and try to use the real clock for the timestamp.",
        "operationId": "SetBlockTimeStampOffset",
        "parameters": [
          {
            "description": "The timestamp offset for blocks in dev mode.",
            "in": "path",
            "name": "offset",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {},
            "description": "OK"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Cannot set timestamp offset to a negative integer."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Given a timestamp offset in seconds, adds the offset to every subsequent block header's timestamp.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/experimental": {
      "get": {
        "operationId": "ExperimentalCheck",
        "responses": {
          "200": {
            "content": {},
            "description": "Experimental API enabled"
          },
          "404": {
            "content": {},
            "description": "Experimental API not enabled"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Returns OK if experimental API is enabled.",
        "tags": [
          "public",
          "experimental"
        ]
      }
    },
    "/v2/ledger/supply": {
      "get": {
        "operationId": "GetSupply",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "Supply represents the current supply of MicroAlgos in the system",
                  "properties": {
                    "current_round": {
                      "description": "Round",
                      "type": "integer"
                    },
                    "online-money": {
                      "description": "OnlineMoney",
                      "type": "integer"
                    },
                    "total-money": {
                      "description": "TotalMoney",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "current_round",
                    "online-money",
                    "total-money"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Supply represents the current supply of MicroAlgos in the system."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get the current supply reported by the ledger.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/ledger/sync": {
      "delete": {
        "description": "Unset the ledger sync round.",
        "operationId": "UnsetSyncRound",
        "responses": {
          "200": {
            "content": {},
            "description": ""
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Sync round not set."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Removes minimum sync round restriction from the ledger.",
        "tags": [
          "public",
          "data"
        ]
      },
      "get": {
        "description": "Gets the minimum sync round for the ledger.",
        "operationId": "GetSyncRound",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "round": {
                      "description": "The minimum sync round for the ledger.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "round"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Response containing the ledger's minimum sync round"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Sync round not set."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Returns the minimum sync round the ledger is keeping in cache.",
        "tags": [
          "public",
          "data"
        ]
      }
    },
    "/v2/ledger/sync/{round}": {
      "post": {
        "description": "Sets the minimum sync round on the ledger.",
        "operationId": "SetSyncRound",
        "parameters": [
          {
            "description": "The round for which the deltas are desired.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {},
            "description": ""
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Can not set sync round to an earlier round than the current round."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Given a round, tells the ledger to keep that round in its cache.",
        "tags": [
          "public",
          "data"
        ]
      }
    },
    "/v2/participation": {
      "get": {
        "description": "Return a list of participation keys",
        "operationId": "GetParticipationKeys",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/ParticipationKey"
                  },
                  "type": "array"
                }
              }
            },
            "description": "A list of participation keys"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Participation Key Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Return a list of participation keys",
        "tags": [
          "private",
          "participating"
        ]
      },
      "post": {
        "operationId": "AddParticipationKey",
        "requestBody": {
          "content": {
            "application/msgpack": {
              "schema": {
                "format": "binary",
                "type": "string"
              }
            }
          },
          "description": "The participation key to add to the node",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "partId": {
                      "description": "encoding of the participation ID.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "partId"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Participation ID of the submission"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Participation Key Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Add a participation key to the node",
        "tags": [
          "private",
          "participating"
        ],
        "x-codegen-request-body-name": "participationkey"
      }
    },
    "/v2/participation/{participation-id}": {
      "delete": {
        "description": "Delete a given participation key by ID",
        "operationId": "DeleteParticipationKeyByID",
        "parameters": [
          {
            "in": "path",
            "name": "participation-id",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {},
            "description": "Participation key got deleted by ID"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Participation Key Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Delete a given participation key by ID",
        "tags": [
          "private",
          "participating"
        ]
      },
      "get": {
        "description": "Given a participation ID, return information about that participation key",
        "operationId": "GetParticipationKeyByID",
        "parameters": [
          {
            "in": "path",
            "name": "participation-id",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ParticipationKey"
                }
              }
            },
            "description": "A detailed description of a participation ID"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Participation Key Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get participation key info given a participation ID",
        "tags": [
          "private",
          "participating"
        ]
      },
      "post": {
        "description": "Given a participation ID, append state proof keys to a particular set of participation keys",
        "operationId": "AppendKeys",
        "parameters": [
          {
            "in": "path",
            "name": "participation-id",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/msgpack": {
              "schema": {
                "format": "binary",
                "type": "string"
              }
            }
          },
          "description": "The state proof keys to add to an existing participation ID",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ParticipationKey"
                }
              }
            },
            "description": "A detailed description of a participation ID"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Participation Key Not Found"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Append state proof keys to a participation key",
        "tags": [
          "private",
          "participating"
        ],
        "x-codegen-request-body-name": "keymap"
      }
    },
    "/v2/shutdown": {
      "post": {
        "description": "Special management endpoint to shutdown the node. Optionally provide a timeout parameter to indicate that the node should begin shutting down after a number of seconds.",
        "operationId": "ShutdownNode",
        "parameters": [
          {
            "in": "query",
            "name": "timeout",
            "schema": {
              "default": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object"
                }
              }
            }
          }
        },
        "tags": [
          "private",
          "nonparticipating"
        ]
      }
    },
    "/v2/stateproofs/{round}": {
      "get": {
        "operationId": "GetStateProof",
        "parameters": [
          {
            "description": "The round for which a state proof is desired.",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/StateProof"
                }
              }
            },
            "description": "StateProofResponse wraps the StateProof type in a response."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Could not find a state proof that covers a given round"
          },
          "408": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "timed out on request"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a state proof that covers a given round",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/status": {
      "get": {
        "operationId": "GetStatus",
        "responses": {
          "200": {
            "description": "NodeStatus contains the information about a node status",
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "catchpoint": {
                      "description": "The current catchpoint that is being caught up to",
                      "type": "string"
                    },
                    "catchpoint-acquired-blocks": {
                      "description": "The number of blocks that have already been obtained by the node as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-processed-accounts": {
                      "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-processed-kvs": {
                      "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-total-accounts": {
                      "description": "The total number of accounts included in the current catchpoint",
                      "type": "integer"
                    },
                    "catchpoint-total-blocks": {
                      "description": "The total number of blocks that are required to complete the current catchpoint catchup",
                      "type": "integer"
                    },
                    "catchpoint-total-kvs": {
                      "description": "The total number of key-values (KVs) included in the current catchpoint",
                      "type": "integer"
                    },
                    "catchpoint-verified-accounts": {
                      "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-verified-kvs": {
                      "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchup-time": {
                      "description": "CatchupTime in nanoseconds",
                      "type": "integer"
                    },
                    "last-catchpoint": {
                      "description": "The last catchpoint seen by the node",
                      "type": "string"
                    },
                    "last-round": {
                      "description": "LastRound indicates the last round seen",
                      "type": "integer"
                    },
                    "last-version": {
                      "description": "LastVersion indicates the last consensus version supported",
                      "type": "string"
                    },
                    "next-version": {
                      "description": "NextVersion of consensus protocol to use",
                      "type": "string"
                    },
                    "next-version-round": {
                      "description": "NextVersionRound is the round at which the next consensus version will apply",
                      "type": "integer"
                    },
                    "next-version-supported": {
                      "description": "NextVersionSupported indicates whether the next consensus version is supported by this node",
                      "type": "boolean"
                    },
                    "stopped-at-unsupported-round": {
                      "description": "StoppedAtUnsupportedRound indicates that the node does not support the new rounds and has stopped making progress",
                      "type": "boolean"
                    },
                    "time-since-last-round": {
                      "description": "TimeSinceLastRound in nanoseconds",
                      "type": "integer"
                    },
                    "upgrade-delay": {
                      "description": "Upgrade delay",
                      "type": "integer"
                    },
                    "upgrade-next-protocol-vote-before": {
                      "description": "Next protocol round",
                      "type": "integer"
                    },
                    "upgrade-no-votes": {
                      "description": "No votes cast for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-node-vote": {
                      "description": "This node's upgrade vote",
                      "type": "boolean"
                    },
                    "upgrade-vote-rounds": {
                      "description": "Total voting rounds for current upgrade",
                      "type": "integer"
                    },
                    "upgrade-votes": {
                      "description": "Total votes cast for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-votes-required": {
                      "description": "Yes votes required for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-yes-votes": {
                      "description": "Yes votes cast for consensus upgrade",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "catchup-time",
                    "last-round",
                    "last-version",
                    "next-version",
                    "next-version-round",
                    "next-version-supported",
                    "stopped-at-unsupported-round",
                    "time-since-last-round"
                  ],
                  "type": "object"
                }
              }
            }
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "type": "string"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Gets the current node status.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/status/wait-for-block-after/{round}": {
      "get": {
        "description": "Waits for a block to appear after round {round} and returns the node's status at the time.",
        "operationId": "WaitForBlock",
        "parameters": [
          {
            "description": "The round to wait until returning status",
            "in": "path",
            "name": "round",
            "required": true,
            "schema": {
              "minimum": 0,
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "NodeStatus contains the information about a node status",
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "catchpoint": {
                      "description": "The current catchpoint that is being caught up to",
                      "type": "string"
                    },
                    "catchpoint-acquired-blocks": {
                      "description": "The number of blocks that have already been obtained by the node as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-processed-accounts": {
                      "description": "The number of accounts from the current catchpoint that have been processed so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-processed-kvs": {
                      "description": "The number of key-values (KVs) from the current catchpoint that have been processed so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-total-accounts": {
                      "description": "The total number of accounts included in the current catchpoint",
                      "type": "integer"
                    },
                    "catchpoint-total-blocks": {
                      "description": "The total number of blocks that are required to complete the current catchpoint catchup",
                      "type": "integer"
                    },
                    "catchpoint-total-kvs": {
                      "description": "The total number of key-values (KVs) included in the current catchpoint",
                      "type": "integer"
                    },
                    "catchpoint-verified-accounts": {
                      "description": "The number of accounts from the current catchpoint that have been verified so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchpoint-verified-kvs": {
                      "description": "The number of key-values (KVs) from the current catchpoint that have been verified so far as part of the catchup",
                      "type": "integer"
                    },
                    "catchup-time": {
                      "description": "CatchupTime in nanoseconds",
                      "type": "integer"
                    },
                    "last-catchpoint": {
                      "description": "The last catchpoint seen by the node",
                      "type": "string"
                    },
                    "last-round": {
                      "description": "LastRound indicates the last round seen",
                      "type": "integer"
                    },
                    "last-version": {
                      "description": "LastVersion indicates the last consensus version supported",
                      "type": "string"
                    },
                    "next-version": {
                      "description": "NextVersion of consensus protocol to use",
                      "type": "string"
                    },
                    "next-version-round": {
                      "description": "NextVersionRound is the round at which the next consensus version will apply",
                      "type": "integer"
                    },
                    "next-version-supported": {
                      "description": "NextVersionSupported indicates whether the next consensus version is supported by this node",
                      "type": "boolean"
                    },
                    "stopped-at-unsupported-round": {
                      "description": "StoppedAtUnsupportedRound indicates that the node does not support the new rounds and has stopped making progress",
                      "type": "boolean"
                    },
                    "time-since-last-round": {
                      "description": "TimeSinceLastRound in nanoseconds",
                      "type": "integer"
                    },
                    "upgrade-delay": {
                      "description": "Upgrade delay",
                      "type": "integer"
                    },
                    "upgrade-next-protocol-vote-before": {
                      "description": "Next protocol round",
                      "type": "integer"
                    },
                    "upgrade-no-votes": {
                      "description": "No votes cast for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-node-vote": {
                      "description": "This node's upgrade vote",
                      "type": "boolean"
                    },
                    "upgrade-vote-rounds": {
                      "description": "Total voting rounds for current upgrade",
                      "type": "integer"
                    },
                    "upgrade-votes": {
                      "description": "Total votes cast for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-votes-required": {
                      "description": "Yes votes required for consensus upgrade",
                      "type": "integer"
                    },
                    "upgrade-yes-votes": {
                      "description": "Yes votes cast for consensus upgrade",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "catchup-time",
                    "last-round",
                    "last-version",
                    "next-version",
                    "next-version-round",
                    "next-version-supported",
                    "stopped-at-unsupported-round",
                    "time-since-last-round"
                  ],
                  "type": "object"
                }
              }
            }
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request -- number must be non-negative integer "
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Gets the node status after waiting for a round after the given round.",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/teal/compile": {
      "post": {
        "description": "Given TEAL source code in plain text, return base64 encoded program bytes and base32 SHA512_256 hash of program bytes (Address style). This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.",
        "operationId": "TealCompile",
        "parameters": [
          {
            "description": "When set to `true`, returns the source map of the program as a JSON. Defaults to `false`.",
            "in": "query",
            "name": "sourcemap",
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "requestBody": {
          "content": {
            "text/plain": {
              "schema": {
                "format": "binary",
                "type": "string"
              }
            }
          },
          "description": "TEAL source code to be compiled",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "hash": {
                      "description": "base32 SHA512_256 of program bytes (Address style)",
                      "type": "string"
                    },
                    "result": {
                      "description": "base64 encoded program bytes",
                      "type": "string"
                    },
                    "sourcemap": {
                      "description": "JSON of the source map",
                      "properties": {},
                      "type": "object"
                    }
                  },
                  "required": [
                    "hash",
                    "result"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Teal compile Result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request - Teal Compile Error"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {},
            "description": "Developer API not enabled"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Compile TEAL source code to binary, produce its hash",
        "tags": [
          "public",
          "nonparticipating"
        ],
        "x-codegen-request-body-name": "source"
      }
    },
    "/v2/teal/disassemble": {
      "post": {
        "description": "Given the program bytes, return the TEAL source code in plain text. This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.",
        "operationId": "TealDisassemble",
        "requestBody": {
          "content": {
            "application/x-binary": {
              "schema": {
                "format": "byte",
                "type": "string"
              }
            }
          },
          "description": "TEAL program binary to be disassembled",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "result": {
                      "description": "disassembled Teal code",
                      "type": "string"
                    }
                  },
                  "required": [
                    "result"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Teal disassembly Result"
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request - Teal Compile Error"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {},
            "description": "Developer API not enabled"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Disassemble program bytes into the TEAL source code.",
        "tags": [
          "public",
          "nonparticipating"
        ],
        "x-codegen-request-body-name": "source"
      }
    },
    "/v2/teal/dryrun": {
      "post": {
        "description": "Executes TEAL program(s) in context and returns debugging information about the execution. This endpoint is only enabled when a node's configuration file sets EnableDeveloperAPI to true.",
        "operationId": "TealDryrun",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DryrunRequest"
              }
            },
            "application/msgpack": {
              "schema": {
                "$ref": "#/components/schemas/DryrunRequest"
              }
            }
          },
          "description": "Transaction (or group) and any accompanying state-simulation data.",
          "required": false
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "error": {
                      "type": "string"
                    },
                    "protocol-version": {
                      "description": "Protocol version is the protocol version Dryrun was operated under.",
                      "type": "string"
                    },
                    "txns": {
                      "items": {
                        "$ref": "#/components/schemas/DryrunTxnResult"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "error",
                    "protocol-version",
                    "txns"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "DryrunResponse contains per-txn debug information from a dryrun."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {},
            "description": "Developer API not enabled"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Provide debugging information for a transaction (or group).",
        "tags": [
          "public",
          "nonparticipating"
        ],
        "x-codegen-request-body-name": "request"
      }
    },
    "/v2/transactions": {
      "post": {
        "operationId": "RawTransaction",
        "requestBody": {
          "content": {
            "application/x-binary": {
              "schema": {
                "format": "binary",
                "type": "string"
              }
            }
          },
          "description": "The byte encoded signed transaction to broadcast to network",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "txId": {
                      "description": "encoding of the transaction hash.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "txId"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Transaction ID of the submission."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request - Malformed Algorand transaction "
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Broadcasts a raw transaction or transaction group to the network.",
        "tags": [
          "public",
          "participating"
        ],
        "x-codegen-request-body-name": "rawtxn"
      }
    },
    "/v2/transactions/params": {
      "get": {
        "operationId": "TransactionParams",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "TransactionParams contains the parameters that help a client construct\na new transaction.",
                  "properties": {
                    "consensus-version": {
                      "description": "ConsensusVersion indicates the consensus protocol version\nas of LastRound.",
                      "type": "string"
                    },
                    "fee": {
                      "description": "Fee is the suggested transaction fee\nFee is in units of micro-Algos per byte.\nFee may fall to zero but transactions must still have a fee of\nat least MinTxnFee for the current network protocol.",
                      "type": "integer"
                    },
                    "genesis-hash": {
                      "description": "GenesisHash is the hash of the genesis block.",
                      "format": "byte",
                      "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$",
                      "type": "string"
                    },
                    "genesis-id": {
                      "description": "GenesisID is an ID listed in the genesis block.",
                      "type": "string"
                    },
                    "last-round": {
                      "description": "LastRound indicates the last round seen",
                      "type": "integer"
                    },
                    "min-fee": {
                      "description": "The minimum transaction fee (not per byte) required for the\ntxn to validate for the current network protocol.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "consensus-version",
                    "fee",
                    "genesis-hash",
                    "genesis-id",
                    "last-round",
                    "min-fee"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "TransactionParams contains the parameters that help a client construct a new transaction."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get parameters for constructing a new transaction",
        "tags": [
          "public",
          "nonparticipating"
        ]
      }
    },
    "/v2/transactions/pending": {
      "get": {
        "description": "Get the list of pending transactions, sorted by priority, in decreasing order, truncated at the end at MAX. If MAX = 0, returns all pending transactions.\n",
        "operationId": "GetPendingTransactions",
        "parameters": [
          {
            "description": "Truncated number of transactions to display. If max=0, returns all pending txns.",
            "in": "query",
            "name": "max",
            "schema": {
              "type": "integer"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "PendingTransactions is an array of signed transactions exactly as they were submitted.",
                  "properties": {
                    "top-transactions": {
                      "description": "An array of signed transaction objects.",
                      "items": {
                        "properties": {},
                        "type": "object",
                        "x-algorand-format": "SignedTransaction"
                      },
                      "type": "array"
                    },
                    "total-transactions": {
                      "description": "Total number of transactions in the pool.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "top-transactions",
                    "total-transactions"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "description": "PendingTransactions is an array of signed transactions exactly as they were submitted.",
                  "properties": {
                    "top-transactions": {
                      "description": "An array of signed transaction objects.",
                      "items": {
                        "properties": {},
                        "type": "object",
                        "x-algorand-format": "SignedTransaction"
                      },
                      "type": "array"
                    },
                    "total-transactions": {
                      "description": "Total number of transactions in the pool.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "top-transactions",
                    "total-transactions"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "A potentially truncated list of transactions currently in the node's transaction pool. You can compute whether or not the list is truncated if the number of elements in the **top-transactions** array is fewer than **total-transactions**."
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a list of unconfirmed transactions currently in the transaction pool.",
        "tags": [
          "public",
          "participating"
        ]
      }
    },
    "/v2/transactions/pending/{txid}": {
      "get": {
        "description": "Given a transaction ID of a recently submitted transaction, it returns information about it.  There are several cases when this might succeed:\n- transaction committed (committed round > 0)\n- transaction still in the pool (committed round = 0, pool error = \"\")\n- transaction removed from pool due to error (committed round = 0, pool error != \"\")\nOr the transaction may have happened sufficiently long ago that the node no longer remembers it, and this will return an error.\n",
        "operationId": "PendingTransactionInformation",
        "parameters": [
          {
            "description": "A transaction ID",
            "in": "path",
            "name": "txid",
            "required": true,
            "schema": {
              "pattern": "[A-Z0-9]+",
              "type": "string"
            }
          },
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PendingTransactionResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/PendingTransactionResponse"
                }
              }
            },
            "description": "Given a transaction ID of a recently submitted transaction, it returns information about it.  There are several cases when this might succeed:\n- transaction committed (committed round > 0)\n- transaction still in the pool (committed round = 0, pool error = \"\")\n- transaction removed from pool due to error (committed round = 0, pool error != \"\")\n\nOr the transaction may have happened sufficiently long ago that the node no longer remembers it, and this will return an error."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Transaction Not Found"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Get a specific pending transaction.",
        "tags": [
          "public",
          "participating"
        ]
      }
    },
    "/v2/transactions/simulate": {
      "post": {
        "operationId": "SimulateTransaction",
        "parameters": [
          {
            "description": "Configures whether the response object is JSON or MessagePack encoded. If not provided, defaults to JSON.",
            "in": "query",
            "name": "format",
            "schema": {
              "enum": [
                "json",
                "msgpack"
              ],
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SimulateRequest"
              }
            },
            "application/msgpack": {
              "schema": {
                "$ref": "#/components/schemas/SimulateRequest"
              }
            }
          },
          "description": "The transactions to simulate, along with any other inputs.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "properties": {
                    "eval-overrides": {
                      "$ref": "#/components/schemas/SimulationEvalOverrides"
                    },
                    "last-round": {
                      "description": "The round immediately preceding this simulation. State changes through this round were used to run this simulation.",
                      "type": "integer"
                    },
                    "txn-groups": {
                      "description": "A result object for each transaction group that was simulated.",
                      "items": {
                        "$ref": "#/components/schemas/SimulateTransactionGroupResult"
                      },
                      "type": "array"
                    },
                    "version": {
                      "description": "The version of this response object.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "last-round",
                    "txn-groups",
                    "version"
                  ],
                  "type": "object"
                }
              },
              "application/msgpack": {
                "schema": {
                  "properties": {
                    "eval-overrides": {
                      "$ref": "#/components/schemas/SimulationEvalOverrides"
                    },
                    "last-round": {
                      "description": "The round immediately preceding this simulation. State changes through this round were used to run this simulation.",
                      "type": "integer"
                    },
                    "txn-groups": {
                      "description": "A result object for each transaction group that was simulated.",
                      "items": {
                        "$ref": "#/components/schemas/SimulateTransactionGroupResult"
                      },
                      "type": "array"
                    },
                    "version": {
                      "description": "The version of this response object.",
                      "type": "integer"
                    }
                  },
                  "required": [
                    "last-round",
                    "txn-groups",
                    "version"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Result of a transaction group simulation."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Bad Request"
          },
          "401": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Invalid API Token"
          },
          "500": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Internal Error"
          },
          "503": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              },
              "application/msgpack": {
                "schema": {
                  "$ref": "#/components/schemas/ErrorResponse"
                }
              }
            },
            "description": "Service Temporarily Unavailable"
          },
          "default": {
            "content": {},
            "description": "Unknown Error"
          }
        },
        "summary": "Simulates a raw transaction or transaction group as it would be evaluated on the network. The simulation will use blockchain state from the latest committed round.",
        "tags": [
          "public",
          "nonparticipating"
        ],
        "x-codegen-request-body-name": "request"
      }
    },
    "/versions": {
      "get": {
        "description": "Retrieves the supported API versions, binary build versions, and genesis information.",
        "operationId": "GetVersion",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Version"
                }
              }
            },
            "description": "VersionsResponse is the response to 'GET /versions'"
          }
        },
        "tags": [
          "public",
          "common"
        ]
      }
    }
  },
  "servers": [
    {
      "url": "https://mainnet-api.algonode.cloud/"
    },
    {
      "url": "https://testnet-api.algonode.cloud/"
    },
    {
      "url": "https://betanet-api.algonode.cloud/"
    }
  ],
  "tags": [
    {
      "name": "private"
    }
  ]
}

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/GoPlausible/algorand-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server